home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / ada / gnat1792.zip / gnat179b / features < prev    next >
Encoding:
Text File  |  1994-06-01  |  14.3 KB  |  372 lines
  1. GNAT IMPLEMENTED FEATURES LIST
  2. Current as of 5/10/94
  3.  
  4. Here is the list of implemented and not implemented features. A more precise
  5. description of the GNAT system is provided in the file 'gnat-intro', which is
  6. part of the GNAT distribution.
  7.  
  8. Features added since GNAT version 1.78
  9. =======================================================================
  10.    The list of features has been reorganized into one list according
  11.    to the reference manual. Things listed are implemented unless specifically
  12.    listed as not being implemented.
  13.  
  14.    Some limited tasking on the Sparc SunOS version only. OS/2 version to 
  15.    follow in a few weeks. (See more detailed list of tasking features below)
  16.  
  17.    More complete documentation of cross referencer (see gnat-intro for details)
  18.  
  19.    access discriminants
  20.    derived enumeration types (exception from type Character)
  21.  
  22.    gnatsplit tool --  to deal with files containing several compilation units.
  23.  
  24.    gkrunch utility
  25.       8 character file names for RTL files to help GNAT on DOS and OS/2
  26.       running under the FAT.
  27.  
  28.    Generic Renaming
  29.  
  30.    Min and Max attributes
  31.  
  32.    Intrinsic Functions (see section in gnat-intro for more details)
  33.  
  34.    String Handling
  35.       The Package Strings
  36.       The Package Strings.Maps
  37.       Fixed-Length String Handling
  38.       Bounded-Length String Handling
  39.       Unbounded-Length String Handling
  40.       String-Handling Sets and Mappings
  41.  
  42. =======================================================================
  43. Status of Features
  44. ------------------
  45.  
  46. The parser is a full Ada9X parser, which implements the Ada 9X language
  47. as defined by version 4.0 of the Draft International Standard. Semantic
  48. analysis and code generation are in constant evolution.
  49.  
  50.   2. Lexical Elements
  51.      2.1 Character Set
  52.      2.2 Lexical Elements, Separators, and Delimiters
  53.      2.3 Identifiers
  54.      2.4 Numeric Literals
  55.          2.4.1 Decimal Literals
  56.          2.4.2 Based Literals
  57.      2.5 Character Literals
  58.      2.6 String Literals
  59.      2.7 Comments
  60.      2.8 Pragmas
  61.          see Appendix B listing for status of Pragmas
  62.      2.9 Reserved Words
  63.  
  64.   3. Declarations and Types
  65.   3.1 Declarations
  66.   3.2 Types and Subtypes
  67.       3.2.1 Type Declarations
  68.       3.2.2 Subtype Declarations
  69.       3.3 Objects and Named Numbers
  70.           3.3.1 Object Declarations
  71.           3.3.2 Number Declarations
  72.       3.4 Derived types and Classes
  73.           3.4.1 Derivation Classes
  74.           Derived types from private types (not implemented yet)
  75.       3.5 Scalar Types
  76.            Attribute 'Base 'Min 'Max
  77.           3.5.1 Enumeration Types
  78.              attributes (first, last, range, pos, val, image)
  79.           3.5.2 Character Types
  80.               attributes (first, last, range, pos, val, image)
  81.           3.5.3 Boolean Types
  82.           3.5.4 Integer Types
  83.               attributes (first, last, range, pos, val, image)
  84.               Modular Types
  85.           3.5.7 Floating Point Types
  86.           3.5.8 Operations of Floating Point Types
  87.               attributes -- see the list below attached with Appendix A
  88.    
  89.           3.5.9 Fixed Point Types                (not implemented yet)
  90.           3.5.10 Operations of Fixed Point Types (not implemented yet)
  91.  
  92.       3.6 Array Types
  93.           3.6.1 Index Constraints and Discrete Ranges
  94.           3.6.2 Operations of Array Types
  95.                 attributes first, last, range, length
  96.           3.6.3 String Types
  97.    
  98.       3.7 Discriminants
  99.           3.7.1 Discriminant Constraints
  100.           3.7.2 Operations of Discriminanted Types
  101.    
  102.       3.8 Record types
  103.           3.8.1 Variant Parts and Discrete Choices
  104.    
  105.        3.9 Tagged Types and Type Extensions
  106.           3.9.1 Type Extensions
  107.           3.9.2 Dispatching Operations and Subprograms
  108.           3.9.3 Abstract Types and Subprograms
  109.                 attribute 'Class
  110.    
  111.        3.10 Access Types
  112.           3.10.1 Incomplete Type Declarations
  113.           3.10.2 Operations of Access Types
  114.                  Access to subprograms
  115.                   attribute 'Access
  116.   4. Names and Expressions
  117.      4.1 Names
  118.          4.1.1 Indexed Components
  119.          4.1.2 Slices
  120.          4.1.3 Selected Components
  121.          4.2 Literals
  122.      4.3 Aggregates
  123.          4.3.1 Record Aggregates
  124.            aggregates for tagged types (not implemented yet)
  125.  
  126.          4.3.3 Array Aggregates
  127.      Exponentiation
  128.      Expressions (all forms)
  129.             static and dynamic concatenation
  130.          type conversions  (except array conversions)
  131.          membership tests, conversion with class-wide types
  132.     
  133.    5. Statements
  134.       5.1 Simple and Compound Statements - Sequences of Statements
  135.       5.2 Assignment Statements
  136.       5.3 If Statements
  137.       5.4 Case Statements
  138.       5.5 Loop Statements
  139.       5.6 Block Statements
  140.       5.7 Exit Statements
  141.       5.8 Goto Statements
  142.     
  143.    6. Subprograms
  144.       6.1 Subprogram Declarations
  145.       6.2 Formal Parameter Modes
  146.       6.3 Subprogram Bodies
  147.           (6.3.1 No Conformance Rules yet)
  148.           (6.3.2 No Inline Expansion of Subprograms yet)
  149.       6.4 Subprogram Calls
  150.           6.4.1 Parameter Associations
  151.       6.5 Return Statements
  152.       6.6 Overloading of Operators
  153.      
  154.    7. Packages
  155.       7.1 Package Specifications and Declarations
  156.       7.2 Package Bodies
  157.       7.3 Private Types (no private extension yet)
  158.       7.3.1 Operations of Private Types
  159.       7.4 Deferred Constants
  160.       7.5 Limited Types
  161.       7.6 User-Defined Assignment and Finalization (simple cases)
  162.           7.6.1 Completion and Finalization (simple cases)
  163.  
  164.    8. Visibility Rules
  165.       8.1 Declarative Region
  166.       8.2 Scope of Declarations
  167.       8.3 Visibility
  168.       8.4 Use Clauses
  169.       8.5 Renaming Declarations
  170.           8.5.1 Object Renaming Declarations
  171.           8.5.2 Exception Renaming Declarations
  172.           8.5.3 Package Renaming Declarations
  173.           8.5.4 Subprogram Renaming Declarations
  174.           8.5.5 Generic Renaming Declarations
  175.       8.6 The Context of Overload Resolution
  176.  
  177.    9. Tasks and Synchronization (Currently on Sparc SunOS verion only)
  178.       9.1 Task Units and Task Objects (and access to task)
  179.       9.2 Task Execution - Task Activation
  180.       9.3 Task Dependence - Termination of Tasks
  181.       9.4 Protected Units and Protected Objects (not implemented)
  182.       9.5 Intertask Communication
  183.           9.5.1 Protected Subprograms (not implemented)
  184.           9.5.2 Entries and Accept Statements (and entry families)
  185.           9.5.3 Entry Calls
  186.           9.5.4 Requeue Statements (not implemented)
  187.       9.6 Delay Statements, Duration, and Time (not implemented)
  188.       9.7 Select Statements
  189.           9.7.1 Selective Accept
  190.           9.7.2 Timed Entry Calls (not implemented)
  191.           9.7.3 Conditional Entry Calls
  192.           9.7.4 Asynchronous Transfer of Control (not implemented)
  193.       9.8 Abort of a Task - Abort of a Sequence of Statements (not implemented)
  194.       9.9 Task and Entry Attributes
  195.           Callable, Count,  Terminated (not implemented)
  196.       9.10 Shared Variables (not implemented)
  197.  
  198.       package Calendar (not implemented yet)
  199.  
  200.    10. Program Structure and Compilation Issues
  201.        10.1 Separate Compilation
  202.            10.1.1 Compilation Units - Library Units
  203.                   (including child units)
  204.            10.1.2 Context Clauses - With Clauses
  205.            10.1.3 Subunits of Compilation Units
  206.            10.1.4 The Compilation Process
  207.            10.1.5 Pragmas and Compilations
  208.            10.1.6 Environment-Level Visibility Rules
  209.         10.2 Program Execution
  210.            10.2.1 Elaboration Control
  211.               (pragmas Elaborate and Elaborate_All)
  212.  
  213.     11. Exceptions
  214.         11.1 Exception Declarations
  215.         11.2 Exception Handlers
  216.         11.3 Raise Statements
  217.         11.4 Exception Handling
  218.         11.5 Suppressing Checks
  219.         11.6 Exceptions and Optimization
  220.  
  221.         limited constraint checking on integer/enumeration types under the
  222.         following catagories:
  223.           Index Checks
  224.           Access Checks
  225.           Range Checks
  226.             Initial values in object declarations.
  227.             Assignment
  228.             parameter passing of IN parameters
  229.             type conversions
  230.  
  231.          No constraint checking on floating point types or modular types.
  232.  
  233.     12. Generic Units
  234.         12.1 Generic Declarations
  235.         12.2 Generic Bodies
  236.         12.3 Generic Instantiation
  237.              Instantiations of decimal types (not implemented yet)
  238.              Instantiations of modular types (not implemented yet)
  239.         12.4 Formal Objects
  240.         12.5 Formal Types
  241.             12.5.1 Formal Private and Derived Types
  242.             12.5.2 Formal Scalar Types
  243.             12.5.3 Formal Array Types
  244.             12.5.4 Formal Access Types
  245.         12.6 Formal Subprograms
  246.         12.7 Formal Packages
  247.  
  248.     13. Representation Clauses and Implementation-Dependent Features
  249.        13.1 Representation Items
  250.        13.2 Pragma Pack (not implemented yet)
  251.        13.3 Representation Attributes
  252.             Address and Size supported; other attributes not implemented
  253.            13.3.1 Attribute Definition Clauses
  254.        13.4 Enumeration Representation Clauses (not implemented yet)
  255.        13.5 Record Layout (not implemented yet)
  256.            13.5.1 Storage Place Attributes
  257.            13.5.2 Bit Ordering
  258.            13.5.3 Record Representation Clauses
  259.        13.6 Change of Representation
  260.        13.7 The Package System
  261.            13.7.1 The Package System.Storage_Elements
  262.        13.8 Machine Code Insertions (not implemented yet)
  263.        13.9 Unchecked Type Conversions
  264.            13.9.1 The Valid Attribute (not implemented yet)
  265.        13.10 Unchecked Access Value Creation
  266.        13.11 Storage Management (not implemented yet)
  267.            13.11.1 The Max_Size_In_Storage_Elements Attribute
  268.            13.11.2 Unchecked Storage Deallocation
  269.            13.11.3 Pragma Controlled
  270.        13.12 Pragma Restrictions
  271.        13.13 Representation Determination
  272.  
  273.     14. Input-Output
  274.        14.1 External Files and File Objects
  275.        14.2 Sequential and Direct Files               (not implemented)
  276.            14.2.1 The Generic Package Sequential_IO   (not implemented)
  277.            14.2.2 File Management                     (not implemented)
  278.            14.2.3 Sequential Input-Output Operations  (not implemented)
  279.            14.2.4 The Generic Package Direct_IO       (not implemented)
  280.            14.2.5 Direct Input-Output Operations      (not implemented)
  281.            14.2.6 The Generic Package Storage_IO
  282.  
  283.        14.3 Text Input-Output
  284.            14.3.1 The Package Text_IO
  285.            14.3.2 Text File Management
  286.            14.3.3 Default Input and Output Files
  287.            14.3.4 Specification of Line and Page Lengths
  288.            14.3.5 Operations on Columns, Lines, and Pages
  289.            14.3.6 Get and Put Procedures
  290.            14.3.7 Input-Output of Characters and Strings
  291.            14.3.8 Input-Output for Integer
  292.                     implemented for type Integer, and Long_Integer if
  293.                     its size is the same as Integer on the particular machine.
  294.                     Not implemented for Long_Long_Integer.
  295.                   Input-Output for Modular Types (not implemented)
  296.            14.3.9 Input-Output for Real Types
  297.                   Input-Output for Float Types (implemented for Float but
  298.                   not Long_Float and Long_Long_Float)
  299.                   Input-Output for Fixed Point Types (not implemented)
  300.                   Also no bounds checking on result.
  301.  
  302.                   Decimal_IO (not implemented yet)
  303.            14.3.10 Input-Output for Enumeration Types
  304.  
  305.        14.4 Wide Text Input-Output                            (not implemented)
  306.        14.5 Stream Input-Output                               (not implemented)
  307.            14.5.1 Stream-Oriented Attributes of Specific Types   ("")
  308.            14.5.2 Stream-Oriented Attributes of Class-Wide Types ("")
  309.            14.5.3 The Package Streams                            ("")
  310.            14.5.4 The Package Streams.Stream_IO                  ("")
  311.  
  312.        14.6 Exceptions in Input-Output
  313.        14.7 File Sharing
  314.  
  315.     A. Core Language-Defined Attributes
  316.  
  317.        A.1 Attributes of Floating Point Types
  318.            Ada 83 attributes:
  319.               digits, epsilon, machine_emax, machine_emin, machine_mantissa,
  320.               machine_overflows, machine_radix, machine_rounds, mantissa,
  321.               safe_emax, safe_large, safe_small
  322.            Ada 9X attributes:
  323.               denorm, emax, large, model_emax, model_emin, model_mantissa,
  324.               model_epsilon, model_small, safe_first, safe_last, signed_zeroes
  325.  
  326.        A.2 Attributes of Fixed Point Typess (not implemented yet)
  327.  
  328.      B. Core Language-Defined Pragmas
  329.         List
  330.         Page
  331.         Optimize               (not implemented)
  332.         Preelaborate           (not implemented)
  333.         Pure                   (not implemented)
  334.         Inline                 (not implemented)
  335.         Elaborate_All
  336.         Elaboate_Body
  337.         Suppress
  338.         Pack                   (not implemented)
  339.         Controlled             (not implemented)
  340.         Restrictions           (not implemented)
  341.         Import
  342.         Export                 (not implemented)
  343.         Convention
  344.  
  345.      C. Predefined Language Environment
  346.  
  347.         C.1 The Package Standard
  348.         C.2 The Package Ada
  349.         C.3 Character Handling
  350.             C.3.1 The Package Characters
  351.             C.3.2 The Package Characters.Latin_1
  352.         C.4 String Handling
  353.             C.4.1 The Package Strings
  354.             C.4.2 The Package Strings.Maps
  355.             C.4.3 Fixed-Length String Handling
  356.             C.4.4 Bounded-Length String Handling
  357.             C.4.5 Unbounded-Length String Handling
  358.             C.4.6 String-Handling Sets and Mappings
  359.             C.4.7 Wide_String Handling                 (not implemented)
  360.         C.5 The Numerics Packages
  361.             C.5.1 Elementary Functions
  362.             C.5.2 Random Number Generation
  363.  
  364.       Annex G. Systems Programming   (not implemented yet)
  365.       Annex H. Real-Time Systems     (not implemented yet)
  366.       Annex I. Distributed Systems   (not implemented yet)
  367.       Annex J. Information Systems   (not implemented yet)
  368.       Annex K. Numerics              (not implemented yet)
  369.         A preliminary version of ada.numerics.generics_complex_functions is
  370.         available, though not extensively tested yet.
  371. 
  372.